Pythonでの並行処理の解放：ThreadPoolExecutor vs. ProcessPoolExecutor

Pythonは、多用途で広く使用されているプログラミング言語ですが、グローバルインタプリタロック（GIL）のために、真の並列処理に関しては特定の制限があります。concurrent.futuresモジュールは、非同期的に呼び出し可能オブジェクトを実行するための高レベルインターフェースを提供し、これらの制限の一部を回避し、特定のタイプのタスクのパフォーマンスを向上させる方法を提供します。このモジュールには、ThreadPoolExecutorとProcessPoolExecutorという2つの主要なクラスがあります。この包括的なガイドでは、両方を詳しく調べ、その違い、長所と短所を強調し、ニーズに合った適切なexecutorを選択するのに役立つ実践的な例を提供します。

並行処理と並列処理の理解

各executorの詳細に入る前に、並行処理と並列処理の概念を理解することが重要です。これらの用語はしばしば同じ意味で使用されますが、異なる意味を持っています。

• 並行処理： 複数のタスクを同時に管理することに関係しています。これは、実際には単一のプロセッサコアでインターリーブされている場合でも、複数のことを同時に処理するようにコードを構造化することです。単一のストーブで複数の鍋を管理するシェフのように考えてください。それらはすべて*まったく同じ*瞬間に沸騰しているわけではありませんが、シェフはそれらすべてを管理しています。
• 並列処理： 通常、複数のプロセッサコアを利用することにより、複数のタスクを*同時に*実際に実行することを含みます。これは、複数のシェフがそれぞれ食事の異なる部分を同時に作業しているようなものです。

PythonのGILは、スレッドを使用する場合、CPUバウンドタスクの真の並列処理を大幅に妨げます。これは、GILが一度に1つのスレッドのみにPythonインタプリタの制御を許可するためです。ただし、I/Oバウンドタスクの場合、プログラムがネットワーク要求やディスク読み取りなどの外部操作の待機に時間を費やす場合、スレッドは、1つのスレッドが待機している間に他のスレッドを実行できるようにすることで、大幅なパフォーマンス向上を提供できます。

concurrent.futuresモジュールの紹介

concurrent.futuresモジュールは、タスクを非同期的に実行するプロセスを簡素化します。スレッドとプロセスを操作するための高レベルインターフェースを提供し、それらを直接管理することに関連する複雑さの多くを抽象化します。コアコンセプトは「executor」であり、提出されたタスクの実行を管理します。2つの主要なexecutorは次のとおりです。

• ThreadPoolExecutor： タスクを実行するためにスレッドのプールを利用します。I/Oバウンドタスクに適しています。
• ProcessPoolExecutor： タスクを実行するためにプロセスのプールを利用します。CPUバウンドタスクに適しています。

ThreadPoolExecutor：I/Oバウンドタスクのためのスレッドの活用

ThreadPoolExecutorは、タスクを実行するためにワーカー・スレッドのプールを作成します。GILがあるため、スレッドは真の並列処理の恩恵を受ける計算集約的な操作には理想的ではありません。ただし、I/Oバウンドのシナリオでは優れています。その使用方法を見てみましょう。

基本的な使用法

ThreadPoolExecutorを使用して複数のWebページを同時にダウンロードする簡単な例を次に示します。

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # 不良応答（4xxまたは5xx）に対するHTTPErrorを発生させます
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # 各URLをexecutorに送信します
    futures = [executor.submit(download_page, url) for url in urls]

    # すべてのタスクが完了するのを待ちます
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

説明：

1. 必要なモジュールをインポートします：concurrent.futures、requests、およびtime。
2. ダウンロードするURLのリストを定義します。
3. download_page関数は、特定のURLのコンテンツを取得します。潜在的なネットワークの問題をキャッチするために、try...exceptとresponse.raise_for_status()を使用してエラー処理が含まれています。
4. 最大4つのワーカー・スレッドを持つThreadPoolExecutorを作成します。max_workers引数は、同時に使用できるスレッドの最大数を制御します。これを高すぎると、特にネットワーク帯域幅がボトルネックになるI/Oバウンドタスクでは、必ずしもパフォーマンスが向上するとは限りません。
5. リスト内包表記を使用して、各URLをexecutor.submit(download_page, url)を使用してexecutorに送信します。これにより、各タスクのFutureオブジェクトが返されます。
6. concurrent.futures.as_completed(futures)関数は、完了した時点でfuturesを生成するイテレータを返します。これにより、結果を処理する前にすべてのタスクが完了するのを待つことを回避できます。
7. 完了したfuturesを反復処理し、future.result()を使用して各タスクの結果を取得し、ダウンロードされた合計バイト数を合計します。download_page内でのエラー処理により、個々の障害がプロセス全体をクラッシュさせることはありません。
8. 最後に、ダウンロードされた合計バイト数と所要時間を印刷します。

ThreadPoolExecutorの利点

• 簡素化された並行処理： スレッドを管理するためのクリーンで使いやすいインターフェースを提供します。
• I/Oバウンドパフォーマンス： ネットワークリクエスト、ファイル読み取り、またはデータベースクエリなど、I/O操作の待機にかなりの時間を費やすタスクに最適です。
• オーバーヘッドの削減： スレッドは通常、プロセスと比較してオーバーヘッドが少ないため、頻繁なコンテキスト切り替えを伴うタスクにはより効率的です。

ThreadPoolExecutorの制限

• GILの制限： GILは、CPUバウンドタスクの真の並列処理を制限します。一度に1つのスレッドのみがPythonバイトコードを実行できるため、複数のコアのメリットが失われます。
• デバッグの複雑さ： レースコンディションやその他の並行処理関連の問題により、マルチスレッドアプリケーションのデバッグは困難になる可能性があります。

ProcessPoolExecutor：CPUバウンドタスクのためのマルチプロセッシングの解放

ProcessPoolExecutorは、ワーカー・プロセスのプールを作成することにより、GILの制限を克服します。各プロセスには独自のPythonインタプリタとメモリー空間があり、マルチコアシステムで真の並列処理を可能にします。これにより、計算量の多いCPUバウンドタスクに最適です。

基本的な使用法

大きな範囲の数値の2乗の合計を計算するなどの計算集約的なタスクを検討してください。ProcessPoolExecutorを使用してこのタスクを並列化する方法は次のとおりです。

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": # 一部の環境での再帰的な生成を回避するために重要です
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

説明：

1. 数値の特定の範囲の2乗の合計を計算する関数sum_of_squaresを定義します。各範囲を実行しているプロセスを確認するために、os.getpid()を含めます。
2. 範囲サイズと使用するプロセスの数を定義します。rangesリストは、総計算範囲をより小さなチャンクに分割するために作成され、プロセスごとに1つずつ作成されます。
3. 指定された数のワーカー・プロセスを持つProcessPoolExecutorを作成します。
4. executor.submit(sum_of_squares, start, end)を使用して、各範囲をexecutorに送信します。
5. future.result()を使用して、各futureから結果を収集します。
6. すべてのプロセスからの結果を合計して、最終的な合計を取得します。

重要事項： ProcessPoolExecutorを使用する場合、特にWindowsでは、executorを作成するコードをif __name__ == "__main__":ブロック内に囲む必要があります。これにより、再帰的なプロセス生成を防ぎ、エラーや予期しない動作につながる可能性があります。これは、モジュールが各子プロセスに再インポートされるためです。

ProcessPoolExecutorの利点

• 真の並列処理： GILの制限を克服し、CPUバウンドタスクのマルチコアシステムでの真の並列処理を可能にします。
• CPUバウンドタスクのパフォーマンスの向上： 計算集約的な操作で大幅なパフォーマンス向上が得られます。
• 堅牢性： 1つのプロセスがクラッシュしても、プロセスは互いに分離されているため、必ずしもプログラム全体が停止するわけではありません。

ProcessPoolExecutorの制限

• より高いオーバーヘッド： プロセスの作成と管理には、スレッドと比較してより高いオーバーヘッドがあります。
• プロセス間通信： プロセス間でデータを共有することはより複雑になる可能性があり、プロセス間通信（IPC）メカニズムが必要であり、オーバーヘッドが増加する可能性があります。
• メモリフットプリント： 各プロセスには独自のメモリー空間があり、アプリケーションの全体的なメモリフットプリントが増加する可能性があります。プロセス間で大量のデータを渡すと、ボトルネックになる可能性があります。

適切なExecutorの選択：ThreadPoolExecutor vs. ProcessPoolExecutor

ThreadPoolExecutorとProcessPoolExecutorのどちらを選択するかの鍵は、タスクの性質を理解することにあります。

• I/Oバウンドタスク： タスクがI/O操作（例：ネットワークリクエスト、ファイル読み取り、データベースクエリ）の待機にほとんどの時間を費やす場合、ThreadPoolExecutorが一般的に優れた選択肢です。GILはこれらのシナリオではボトルネックになりにくく、スレッドのオーバーヘッドが少ないため、より効率的です。
• CPUバウンドタスク： タスクが計算集約的で複数のコアを利用する場合、ProcessPoolExecutorを使用する必要があります。GILの制限を回避し、真の並列処理を可能にし、大幅なパフォーマンス向上をもたらします。

主な違いをまとめた表を以下に示します。

機能	ThreadPoolExecutor	ProcessPoolExecutor
並行処理モデル	マルチスレッド	マルチプロセッシング
GILの影響	GILによって制限されます	GILをバイパス
適しているもの	I/Oバウンドタスク	CPUバウンドタスク
オーバーヘッド	低い	高い
メモリフットプリント	低い	高い
プロセス間通信	不要（スレッドはメモリを共有）	データの共有に必要
堅牢性	あまり堅牢ではありません（クラッシュはプロセス全体に影響を与える可能性があります）	より堅牢（プロセスは分離されています）

高度なテクニックと考慮事項

引数を使用したタスクの送信

どちらのexecutorでも、実行される関数に引数を渡すことができます。これはsubmit()メソッドを通じて行われます。

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

例外の処理

実行された関数内で発生した例外は、メインスレッドまたはプロセスに自動的に伝播されません。Futureの結果を取得するときに、それらを明示的に処理する必要があります。

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"An exception occurred: {e}")

簡単なタスクにmapを使用する

同じ関数を一連の入力に適用する単純なタスクの場合、map()メソッドはタスクを送信する簡潔な方法を提供します。

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

ワーカー数の制御

ThreadPoolExecutorとProcessPoolExecutorの両方のmax_workers引数は、同時に使用できるスレッドまたはプロセスの最大数を制御します。max_workersに適切な値を選択することは、パフォーマンスにとって重要です。適切な開始点は、システムで使用可能なCPUコアの数です。ただし、I/Oバウンドタスクの場合は、スレッドがI/Oを待機している間、他のタスクに切り替えることができるため、コアよりも多くのスレッドを使用することが有効な場合があります。最適な値を決定するには、実験とプロファイリングがしばしば必要です。

進捗状況の監視

concurrent.futuresモジュールは、タスクの進捗状況を直接監視するための組み込みメカニズムを提供していません。ただし、コールバックまたは共有変数を使用して独自の進捗状況追跡を実装できます。tqdmのようなライブラリを統合して、プログレスバーを表示できます。

実際の例

ThreadPoolExecutorとProcessPoolExecutorを効果的に適用できる実際のシナリオをいくつか見てみましょう。

• Webスクレイピング： ThreadPoolExecutorを使用して、複数のWebページを同時にダウンロードして解析します。各スレッドは異なるWebページを処理できるため、スクレイピングの全体的な速度が向上します。Webサイトの利用規約に注意し、サーバーを過負荷にしないようにしてください。
• 画像処理： ProcessPoolExecutorを使用して、大量の画像に画像フィルターまたは変換を適用します。各プロセスは異なる画像を処理できるため、マルチコアを利用して処理を高速化できます。効率的な画像操作には、OpenCVなどのライブラリを検討してください。
• データ分析： ProcessPoolExecutorを使用して、大規模なデータセットに対して複雑な計算を実行します。各プロセスはデータのサブセットを分析できるため、分析にかかる全体的な時間が短縮されます。PandasとNumPyは、Pythonでのデータ分析でよく使用されるライブラリです。
• 機械学習： ProcessPoolExecutorを使用して、機械学習モデルをトレーニングします。一部の機械学習アルゴリズムは効果的に並列化できるため、トレーニング時間を短縮できます。scikit-learnやTensorFlowなどのライブラリは、並列処理のサポートを提供します。
• ビデオエンコーディング： ProcessPoolExecutorを使用して、ビデオファイルをさまざまな形式に変換します。各プロセスは異なるビデオセグメントをエンコードできるため、全体的なエンコードプロセスが高速化されます。

グローバルな考慮事項

グローバルなオーディエンス向けの並行アプリケーションを開発する場合、次の点を考慮することが重要です。

• タイムゾーン： 時間に敏感な操作を扱う場合は、タイムゾーンに注意してください。pytzのようなライブラリを使用して、タイムゾーンの変換を処理します。
• ロケール： アプリケーションがさまざまなロケールを正しく処理していることを確認してください。localeなどのライブラリを使用して、ユーザーのロケールに従って数値、日付、通貨の形式を設定します。
• 文字エンコーディング： Unicode（UTF-8）をデフォルトの文字エンコーディングとして使用して、さまざまな言語をサポートします。
• 国際化（i18n）とローカライズ（l10n）： アプリケーションを簡単に国際化およびローカライズできるように設計します。gettextまたはその他の翻訳ライブラリを使用して、さまざまな言語の翻訳を提供します。
• ネットワークレイテンシ： リモートサービスとの通信時には、ネットワークレイテンシを考慮してください。適切なタイムアウトとエラー処理を実装して、アプリケーションがネットワークの問題に対して回復力を持つようにします。サーバーの地理的な場所は、レイテンシに大きく影響する可能性があります。異なる地域のユーザーのパフォーマンスを向上させるために、コンテンツ配信ネットワーク（CDN）の使用を検討してください。

結論

concurrent.futuresモジュールは、Pythonアプリケーションに並行処理と並列処理を導入するための強力で便利な方法を提供します。ThreadPoolExecutorとProcessPoolExecutorの違いを理解し、タスクの性質を慎重に検討することにより、コードのパフォーマンスと応答性を大幅に向上させることができます。コードをプロファイリングし、さまざまな構成を試して、特定のユースケースに最適な設定を見つけることを忘れないでください。また、GILの制限と、マルチスレッドおよびマルチプロセッシングプログラミングの潜在的な複雑さに注意してください。慎重な計画と実装により、Pythonでの並行処理の可能性を最大限に引き出し、グローバルなオーディエンス向けの堅牢でスケーラブルなアプリケーションを作成できます。